from datetime import datetime

from flask import request

from flask_jwt_extended import jwt_required
from flask_restx import Namespace, Resource, fields
from app1 import db

from app1.models import Zbfwbroleperm, Zbfwbrole, Zbfwbperm

# 创建 Flask-RESTx 命名空间
ns_role_perm = Namespace('ns_role_perm', description='Role Perm operations')

# 使用 Flask-RESTx 定义用户数据模型
role_perm_model = ns_role_perm.model('Zbfwbroleperm', {
    'id': fields.Integer(readOnly=True, description='The role perm unique identifier'),
    'rid': fields.String(required=True, description='uid'),
    'pid': fields.String(required=True, description='rid'),
    'desc': fields.String(required=True, description='desc'),
    'create_time': fields.DateTime(description='Role Perm creation time'),
    'update_time': fields.DateTime(description='Role Perm update time')
})

# 定义外层的响应模型
response_role_perm_model = ns_role_perm.model('Response_Role_Perm', {
    'message': fields.Nested(ns_role_perm.model('Message_Role_Perm', {
        "result": fields.Integer(description='查询结果返回值'),
        "result_text": fields.String(description='查询结果信息'),
        'count': fields.Integer(description='查询结果返回数据条数'),
        'data': fields.List(fields.Nested(role_perm_model))
    }))
})

# 使用 Flask-RESTx 定义用户数据模型
role_perm_query_model = ns_role_perm.model('Zbfwbroleperm', {
    'id': fields.Integer(required=True, description='The role perm unique identifier'),
    'rid': fields.Integer(required=True, description='The role  unique identifier'),
    'pid': fields.Integer(required=True, description='The perm unique identifier'),
    'desc': fields.String(required=True, description='desc', default=""),
})

# 使用 Flask-RESTx 定义用户数据模型
role_perm_add_model = ns_role_perm.model('Zbfwbrolepermadd', {
    'rid': fields.Integer(required=True, description='The role  unique identifier'),
    'pid': fields.Integer(required=True, description='The perm unique identifier'),
    'desc': fields.String(required=True, description='desc', default=""),
})

# 使用 Flask-RESTx 定义用户数据模型
role_perm_delete_model = ns_role_perm.model('Zbfwbrolepermdelete', {
    'id': fields.Integer(required=True, description='The role perm unique identifier'),
})

# 使用 Flask-RESTx 定义用户数据模型
role_perm_upd_model = ns_role_perm.model('Zbfwbrolepermupd', {
    'id': fields.Integer(required=True, description='The role perm unique identifier'),
    'rid': fields.Integer(required=True, description='The role  unique identifier'),
    'pid': fields.Integer(required=True, description='The perm unique identifier'),
    'desc': fields.String(required=True, description='desc', default=""),
})


# 查询
@ns_role_perm.route('/Role_perm_list')
class RoleResource(Resource):
    # @jwt_required()
    @ns_role_perm.expect(role_perm_query_model)
    @ns_role_perm.marshal_with(response_role_perm_model)
    def post(self):
        """根据输入的id 或者 rid 或者 pid 匹配查询，如果输入值为空或零，则指匹配全部"""
        data = request.get_json()

        # 构建查询条件
        query = Zbfwbroleperm.query
        if 'id' in data and data['id']:
            query = query.filter_by(id=data['id'])
        if 'rid' in data and data['rid']:
            query = query.filter_by(rid=data['rid'])
        if 'pid' in data and data['pid']:
            query = query.filter_by(pid=data['pid'])
        if 'desc' in data and data['desc']:
            query = query.filter(Zbfwbroleperm.desc.like(f"%{data['desc']}%"))

        role_perms = query.all()

        return {
            'message': {
                'result': 0,
                'result_text': '查询成功',
                'count': len(role_perms),
                'data': [rp.to_dict() for rp in role_perms]
            }
        }


# 新增
@ns_role_perm.route('/Role_perm_create')
class RoleAddResource(Resource):
    # @jwt_required()
    @ns_role_perm.expect(role_perm_add_model)
    @ns_role_perm.marshal_with(response_role_perm_model)
    def post(self):
        """ id 为当前总记录加1，rid pid 需要输入"""
        data = request.get_json()

        # 检查必填字段
        if not data.get('rid') or not data.get('pid'):
            return {
                'message': {
                    'result': 1,
                    'result_text': '角色ID和权限ID不能为空',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 检查角色是否存在
        role = Zbfwbrole.query.filter_by(zbfwb_role_id=data['rid']).first()
        if not role:
            return {
                'message': {
                    'result': 1,
                    'result_text': f'角色ID {data["rid"]} 不存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 检查权限是否存在
        perm = Zbfwbperm.query.get(data['pid'])
        if not perm:
            return {
                'message': {
                    'result': 1,
                    'result_text': f'权限ID {data["pid"]} 不存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 检查关系是否已存在
        existing = Zbfwbroleperm.query.filter_by(
            rid=data['rid'],
            pid=data['pid']
        ).first()

        if existing:
            return {
                'message': {
                    'result': 1,
                    'result_text': '该角色权限关系已存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        try:
            # 创建新关系
            new_role_perm = Zbfwbroleperm(
                rid=data['rid'],
                pid=data['pid'],
                desc=data.get('desc')
            )

            db.session.add(new_role_perm)
            db.session.commit()

            # 重新查询以获取关联的角色和权限信息
            created_role_perm = Zbfwbroleperm.query.get(new_role_perm.id)

            return {
                'message': {
                    'result': 0,
                    'result_text': '角色权限关系创建成功',
                    'count': 1,
                    'data': [created_role_perm.to_dict()]
                }
            }, 201
        except Exception as e:
            db.session.rollback()
            return {
                'message': {
                    'result': 1,
                    'result_text': f'创建角色权限关系失败: {str(e)}',
                    'count': 0,
                    'data': []
                }
            }, 500


# 删除
@ns_role_perm.route('/Role_perm_delete')
class RoleDeleteResource(Resource):
    # @jwt_required()
    @ns_role_perm.expect(role_perm_delete_model)
    @ns_role_perm.marshal_with(response_role_perm_model)
    def post(self):
        """Delete a role perm"""
        data = request.get_json()

        if not data.get('id'):
            return {
                'message': {
                    'result': 1,
                    'result_text': 'ID不能为空',
                    'count': 0,
                    'data': []
                }
            }, 400

        try:
            # 先获取完整数据用于返回
            role_perm = Zbfwbroleperm.query.get(data['id'])
            if not role_perm:
                return {
                    'message': {
                        'result': 1,
                        'result_text': '角色权限关系不存在',
                        'count': 0,
                        'data': []
                    }
                }, 404

            # 在删除前先获取需要返回的数据
            response_data = role_perm.to_dict()

            # 执行删除操作
            db.session.delete(role_perm)
            db.session.commit()

            return {
                'message': {
                    'result': 0,
                    'result_text': '角色权限关系删除成功',
                    'count': 1,
                    'data': [response_data]
                }
            }
        except Exception as e:
            db.session.rollback()
            return {
                'message': {
                    'result': 1,
                    'result_text': f'删除角色权限关系失败: {str(e)}',
                    'count': 0,
                    'data': []
                }
            }, 500


# 修改
@ns_role_perm.route('/Role_perm_updt')
class RoleUpdateResource(Resource):
    # @jwt_required()
    @ns_role_perm.expect(role_perm_upd_model)
    @ns_role_perm.marshal_with(response_role_perm_model)
    def post(self):
        """Update a role perm"""
        data = request.get_json()

        # 检查必填字段
        if not data.get('id') or not data.get('rid') or not data.get('pid'):
            return {
                'message': {
                    'result': 1,
                    'result_text': 'ID、角色ID和权限ID不能为空',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 检查角色是否存在
        role = Zbfwbrole.query.filter_by(zbfwb_role_id=data['rid']).first()
        if not role:
            return {
                'message': {
                    'result': 1,
                    'result_text': f'角色ID {data["rid"]} 不存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 检查权限是否存在
        perm = Zbfwbperm.query.get(data['pid'])
        if not perm:
            return {
                'message': {
                    'result': 1,
                    'result_text': f'权限ID {data["pid"]} 不存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        # 查找要更新的关系
        role_perm = Zbfwbroleperm.query.get(data['id'])
        if not role_perm:
            return {
                'message': {
                    'result': 1,
                    'result_text': '角色权限关系不存在',
                    'count': 0,
                    'data': []
                }
            }, 404

        # 检查是否与其他记录冲突
        existing = Zbfwbroleperm.query.filter(
            Zbfwbroleperm.rid == data['rid'],
            Zbfwbroleperm.pid == data['pid'],
            Zbfwbroleperm.id != data['id']
        ).first()

        if existing:
            return {
                'message': {
                    'result': 1,
                    'result_text': '该角色权限关系已存在',
                    'count': 0,
                    'data': []
                }
            }, 400

        try:
            # 更新关系
            role_perm.rid = data['rid']
            role_perm.pid = data['pid']
            role_perm.desc = data.get('desc', role_perm.desc)
            role_perm.update_time = datetime.utcnow()

            db.session.commit()

            # 重新查询以获取关联的角色和权限信息
            updated_role_perm = Zbfwbroleperm.query.get(data['id'])

            return {
                'message': {
                    'result': 0,
                    'result_text': '角色权限关系更新成功',
                    'count': 1,
                    'data': [updated_role_perm.to_dict()]
                }
            }
        except Exception as e:
            db.session.rollback()
            return {
                'message': {
                    'result': 1,
                    'result_text': f'更新角色权限关系失败: {str(e)}',
                    'count': 0,
                    'data': []
                }
            }, 500
